<?php

// włączamy plik z klasą definiującą pola w rodzaju zawartości modułu
require_once('classes/fielddefinitions/GcFieldDefinitions.class.php');

define('PAGES_SHOWN_IN_GC_PAGER', 3);


/**
 * Themka zajmująca się wyświetlaniem linku do elementu katalogu w nawigacji
 * @param $groupNid
 *  numer node'a od którego należy wygenerować link
 * @param $isMain
 *  czy jest to grupa główna (wyświetlana w korzeniu grupy)
 * @param $fragment
 *  fragment jaki nalezy dokleić do adresu
 * @param $hasChilds
 *  czy pod tą grupę podpięte są inne grupy
 * @param $isActive
 *  czy link ten jest aktywnie wybrany
 * @return unknown_type
 */
function theme_groups_catalog_navigation_link($title, $isMain, $groupNid, $fragment, $hasChilds, $isActive = false) {

	$output = '';
  // zmienna na wszystkie klasy połączone z linkiem
  $class = '';
  $class .= 'group_link ';
  $class .= $hasChilds ? 'has_childs ' : '';
  $class .= $isActive ? 'is_active ' : '';
  $output = l($title ,'node/'.$groupNid, array( 'query' => $fragment, 'attributes' => array ('class' => $class, 'nodeid' => $groupNid)) ) ;
 
  return $output;
}

/**
 * Funckja wyświetlająca menu ze wszystkimi kategoriami w sklepie
 * @param int $delta
 *   
 * @return string
 */
function theme_group_catalog_navigation($type) {

	$output .= _group_catalog_navigation_domplusdom_routine($type);

	
  return $output;
}

function _gc_get_group_to_be_selected() {
  // czy jesteśmy w którejść grupie ?
  $where = $_GET['group'];
  $resp = 0;
  if($where) {
    $where = explode(",", $where);
    // w pierwszym elemencie tablicy mamy informację o pierwszej grupie 
    // na drodze do grupy aktualnej. Czyli jest to nasza grupa główna 
    // względem aktualnej grupy
    $resp = $where[0];
  }
  return $resp;
  
}

function _group_catalog_navigation_domplusdom_routine($type) {
	return _group_catalog_navigation_root_routine($type);
}

/**
 * Funkcja tworząca drzewo bocznej nawigacji złożone jedynie z grup głównych
 * @return unknown_type
 */
function _group_catalog_navigation_root_routine($type) {
  // pobieramy id grupy, którą trzeba podświetlić
  $groupToBeSelected = _gc_get_group_to_be_selected();
  
  // pobieramy listę grup głównych
  $groups = _groups_catalog_get_main_groups($type);
  $output = '';
  $output .= '<ul id="nav" class="groups_catalog">';
  
  foreach($groups as $group) {
    $groupNode = node_load($group);
    $fragment = 'group='.$group;
    $output .= '<li>';
     $output .= 
     theme(
            'groups_catalog_navigation_link',
            $groupNode->title, 
            true, 
            $group, 
            $fragment, 
            false, 
            $groupToBeSelected == $group
          );
    
    $output .= '</li>';
  }
  
  $output .= '</ul>'; 
    
  return $output;
}



function _prepare_link_item(&$node) {
  $link = array();
  $link['link_path'] = 'node/'.$node->nid;
  $link['link_title'] = $node->title;
  $link['menu_name'] = 'menu-group-catalog';
  $link['plid'] = 0;
  
  return $link;
}



function _groups_catalog_get_main_groups($type = 'catalog_group') {

	static $cache = array();
	if(!$cache[$type]) {
		$q = db_query(db_rewrite_sql("SELECT n.nid FROM {node} n 
					RIGHT JOIN {gc_main_groups} g ON n.nid = g.nid
	                LEFT JOIN {content_field_group_weight} w ON g.nid = w.nid 
	                WHERE g.type = '%s' ORDER BY w.field_group_weight_value ASC"),$type);
	  $ans = array();
	  while ($res = db_fetch_object($q)) {

	  	 	$ans[] = $res->nid;

	  }
	  
	  $cache[$type] = $ans;
	}
  
  return $cache[$type];
}

function _groups_catalog_is_main_group($groupNid) {
	return db_result(db_query("SELECT nid FROM {gc_main_groups} WHERE nid = '%d' LIMIT 1",$groupNid));
}

function _group_has_childs(&$group) {
  $field = GcFieldDefinitions::contentReferersFieldName($group->type);
  return count($group->{$field}[0]);
  
}

function _group_childs(&$group) {
  $field = GcFieldDefinitions::contentReferersFieldName($group->type);
	return $group->{$field}[0]['items'];
  
}

function _group_has_content(&$group) {
  $field = GcFieldDefinitions::contentReferenceFieldName($group->type);
  //sprawdzamy czy mamy treść w tym polu, które odpowiada za przechowywanie zawartości grup
  if(count($group->{$field}) > 1) {
  	return true;
  } else if ($group->{$field}[0]['nid']) {
  	return true;
  }
  
  return false;
  
  
}

function _group_get_content_nids_routine(&$group,$depth = 0) {
  
  /**
   *  zakładamy, że nie będzie głębiej zagnieżdżonych kategorii, więc jeśli doszliśmy aż
   *  do dziesiątego poziomu zagnieżdżenia, to ktoś mocno przesadził i wracamy z pustą tablicą
   */  
  if ($depth > 10) {
    return array();
  }
  $nids = array();
  
  // obliczamy nazwę pola zawierającego treści dla tej grupy
  
  $reference_field = GcFieldDefinitions::contentReferenceFieldName($group->type);
  
  /*
   * Dodajemy do listy zwracanych treści te, które siedzą bezpośrednio w tej kategorii
   */
  if (_group_has_content($group)) {
  	
    foreach($group->{$reference_field} as $content) {
       $nids[] = $content['nid'];
    }
  }
  
  /*
   * Sprawdzamy czy kategoria ma podkategorie. Jeśli tak to dla każdej z nich odpalamy 
   * rekurencyjne wywołanie
   */
  if (_group_has_childs($group)) {
      foreach((array)_group_childs($group) as $subGroup) {
        $subGroup = node_load($subGroup['nid']);
        
        // wywołanie rekurencyjne
        $nids = array_merge($nids,_group_get_content_nids_routine($subGroup, $depth + 1));
      }
   }
   return $nids; 
}


/**
 * Funkcja pozyskująca listę produktów należących do danej grupy
 * 
 * @param $group
 *    numer node'a będącego aktualnie przeszukiwaną grupą
 * @param $depth
 *    głębokość do której doszliśmy podczas wywołań rekurencyjnych
 * @return array
 *    Tablica zawierająca numery node'ów będących produktami w sklepie, które zawarte są w tej kategori
 */
function _group_get_content_nids(&$group,$depth = 0) {
	
	$nids = array_unique(_group_get_content_nids_routine(&$group,$depth ));
 
 return $nids;
 
}

/*function groups_catalog_prepare_filters_query() {
	$query = '';
	$query = "SELECT pid FROM {gc_filters_products_map} WHERE ";
	$query
}*/

function theme_group_catalog_content(&$node,$depth = 0) {  
   $cols = variable_get('groups_content_cols_per_row',4);
   $rowsPerPage = variable_get('groups_content_rows_per_page',4);
   $nidsPerPage = $cols * $rowsPerPage;  
   $output = '';
   // czy mamy cokolwiek do wyświedtlania/filtrowania ?
   if(is_array($node->products_nids) && count($node->products_nids)) { /* MASTER IF */
	   /* 
	    * przygotowujemy odpowiednie zapytanie wyłuskujące 
	    * tablicę numerów identyfikacyjnych treści 
	    */
	   
	   // sprawdzenie czy został włączony moduł gc_filters 
	   if (module_exists('gc_filters')) {
	   	
	   	// czyli mamy dostęp do obiektu GcFilter
	   	 $gcFiltrationHandler = new GcFiltrationHandler($node);
	   	/* $filtrationQuery = $gcFiltrationHandler->prepareFiltrationQuery();
	   	 $filtrationValues = $gcFiltrationHandler->prepareFiltrationQueryValues();*/
	   	 $gcFiltrationHandler->prepareTemporaryTable();
       $query = pager_query("SELECT nid FROM gc_filtration_temp_table");
	   	 //$query = pager_query($filtrationQuery,$nidsPerPage, 0, NULL, $filtrationValues);
	   	 
	   	 
	   } else {
	   	 
	     	// jeśli nie to generujemy pager_query w oparciu o całą zawartość grupy
	     	$query = pager_query("SELECT nid FROM {node} WHERE nid IN (".db_placeholders($node->products_nids).") " ,$nidsPerPage, 0, NULL, $node->products_nids);     
	   }
	   
	// agregujemy pozyskane nidy w tablicy 
     while($res = db_fetch_object($query) ) {
        $contentNids[] = $res->nid;
     }
     
     
     $contentNidsCount = count($contentNids);
     $output .= '<div id="groups_catalog_pager_top">' . theme('pager') . '</div>';
     $output .= '<div id="group_content">';
     
     
     $output .= '<table id="group_content_table">';
     while($contentNidsCount) {    
      $output .= '<tr>';
      for($i = 0; $i<$cols; $i++) {
        $tempNid = array_shift($contentNids);
        // czy nie został przypadkiem wcześniej usunięty ten node
          $tempNode = node_load($tempNid);
        if($tempNode) {
          $tempNode->reffered_by = 'groups_catalog_'.$node->type; // zmienna wykorzystywana przez themkę
          $output .= '<td>';  
            $output .= node_view($tempNode, TRUE, FALSE);
          $output .= '</td>';
        } else {        
          /* jeśli aktualna wartość nid wynosi zero,
          * co oznacza, albo nieobsługiwalną sytuację wyjątkową,
          * albo informuje, iż treść została już usunięta, 
          * to cofamy się o jeden krok w aktualnej iteracji pętli FOR
          */
          $i--;
        }
        $contentNidsCount--;
        
        // czy nie zużyliśmy już wszystkich nodeów z listy
        if($contentNidsCount <= 0) {
          
          /* zyżyliśmy wszystkie node'y z listy.
           * Wyskakujemy z pętli FOR, a następnie (po sprawdzeniu warunku) z pętli WHILE
           */
          break;
        }
        
      } /* END FOR */   
      $output .= '</tr>';   
      
    } /* END WHILE */
    
    $output .= '</table>'; //#group_content_table
    $output .= '</div>'; // #group_content
    $output .= '<div id="groups_catalog_pager_bottom">' . theme('pager') . '</div>';
   } /* END MASTER IF */
   return $output;
}

/**
 * Funkcja tworząca strukturę przeglądanej aktualnie grupy
 * @param $where
 *    do której grupy/podgrupy weszliśmy
 * @param $fragment
 *    zmienna służąca do wywołania rekurencyjnego
 * @return String
 *    sformatowana lista kategorii
 */
function _group_catalog_navigation_routine($where,$fragment = 'group=') {
    
    $fragment .= $where[0];
    $node = node_load($where[0]);
    
    $output = '';
    $output .= '<ul>';
      $output .= '<li>'; 
        $output .= l($node->title,'node/'.$where[0],array( 'query' => $fragment));
        if(_group_has_childs($node)) {
          
          $output .= '<ul>';
            
          // pobieramy wszystkie podgrupy przypisane do tej grupy
          $childs = _group_childs($node);
          $sortedChilds = groups_catalog_sort_childs($childs);
          foreach($sortedChilds as $child) {
              $childNid = $child;
              /*
               * ładujemy każdą z podgrup i wykonujemy wołanie rekurencyjne
               * tworząc przy okazji odpowiednią strukturę listy
               */ 
          	
              $childNode = node_load($childNid);
              $output .= '<li>';
              
              if ($where[1] && $childNid == $where[1]) {
                
                $temp = $where;
                array_shift($temp);
                $output .= _group_catalog_navigation_routine($temp,$fragment.',');
              } else {
                $output .= l($childNode->title, 'node/'.$childNid,array( 'query' => $fragment.','.$childNid));
              }
              $output .= '</li>';
          }
          $output .= '</ul>';
        }
       $output .= '</li>';
     $output .= '</ul>';

    
  return $output;
}

/** Funkcja do ustawiania listy grup w porządku wagowym 
 * @param unknown_ype $childs
 * @return unknown_type
 */
function groups_catalog_sort_childs($childs) {

	$childNodes = array();
	foreach($childs as $child) {
		$tempNode = node_load($child['nid']);
		// w kluczu zapisujemy numer nida (bo są unikatowe)
		// a w wartości wagę.
		// Po posortowaniu względem klucza z zachowaniem przypisania klucza do wartości
		// będziemy mieli wynik
		$childNodes[$child['nid']] = $tempNode->field_group_weight[0]['value'];
	}
	asort($childNodes);

	return array_keys($childNodes);
}

function _groups_catalog_set_bread() {
  $bread = $_GET['group'];
  $bread = explode( ","  , $bread);
  $breadcrumb = drupal_get_breadcrumb();
  $newBread = 'group=';
  foreach($bread as $nid) {
    $newBread .= $nid;
    $node = node_load($nid);
    
    $breadcrumb[] = l($node->title,'node/'.$nid,array( 'query' => $newBread));
    $newBread .= ",";
  }
  drupal_set_breadcrumb($breadcrumb);
}